home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / urllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  49KB  |  1,776 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Open an arbitrary URL.
  5.  
  6. See the following document for more info on URLs:
  7. "Names and Addresses, URIs, URLs, URNs, URCs", at
  8. http://www.w3.org/pub/WWW/Addressing/Overview.html
  9.  
  10. See also the HTTP spec (from which the error codes are derived):
  11. "HTTP - Hypertext Transfer Protocol", at
  12. http://www.w3.org/pub/WWW/Protocols/
  13.  
  14. Related standards and specs:
  15. - RFC1808: the "relative URL" spec. (authoritative status)
  16. - RFC1738 - the "URL standard". (authoritative status)
  17. - RFC1630 - the "URI spec". (informational status)
  18.  
  19. The object returned by URLopener().open(file) will differ per
  20. protocol.  All you know is that is has methods read(), readline(),
  21. readlines(), fileno(), close() and info().  The read*(), fileno()
  22. and close() methods work like those of open files.
  23. The info() method returns a mimetools.Message object which can be
  24. used to query various info about the object, if available.
  25. (mimetools.Message objects are queried with the getheader() method.)
  26. '''
  27. import string
  28. import socket
  29. import os
  30. import time
  31. import sys
  32. from urlparse import urljoin as basejoin
  33. __all__ = [
  34.     'urlopen',
  35.     'URLopener',
  36.     'FancyURLopener',
  37.     'urlretrieve',
  38.     'urlcleanup',
  39.     'quote',
  40.     'quote_plus',
  41.     'unquote',
  42.     'unquote_plus',
  43.     'urlencode',
  44.     'url2pathname',
  45.     'pathname2url',
  46.     'splittag',
  47.     'localhost',
  48.     'thishost',
  49.     'ftperrors',
  50.     'basejoin',
  51.     'unwrap',
  52.     'splittype',
  53.     'splithost',
  54.     'splituser',
  55.     'splitpasswd',
  56.     'splitport',
  57.     'splitnport',
  58.     'splitquery',
  59.     'splitattr',
  60.     'splitvalue',
  61.     'splitgophertype',
  62.     'getproxies']
  63. __version__ = '1.17'
  64. MAXFTPCACHE = 10
  65. if os.name == 'mac':
  66.     from macurl2path import url2pathname, pathname2url
  67. elif os.name == 'nt':
  68.     from nturl2path import url2pathname, pathname2url
  69. elif os.name == 'riscos':
  70.     from rourl2path import url2pathname, pathname2url
  71. else:
  72.     
  73.     def url2pathname(pathname):
  74.         """OS-specific conversion from a relative URL of the 'file' scheme
  75.         to a file system path; not recommended for general use."""
  76.         return unquote(pathname)
  77.  
  78.     
  79.     def pathname2url(pathname):
  80.         """OS-specific conversion from a file system path to a relative URL
  81.         of the 'file' scheme; not recommended for general use."""
  82.         return quote(pathname)
  83.  
  84. _urlopener = None
  85.  
  86. def urlopen(url, data = None, proxies = None):
  87.     '''urlopen(url [, data]) -> open file-like object'''
  88.     global _urlopener
  89.     if proxies is not None:
  90.         opener = FancyURLopener(proxies = proxies)
  91.     elif not _urlopener:
  92.         opener = FancyURLopener()
  93.         _urlopener = opener
  94.     else:
  95.         opener = _urlopener
  96.     if data is None:
  97.         return opener.open(url)
  98.     else:
  99.         return opener.open(url, data)
  100.  
  101.  
  102. def urlretrieve(url, filename = None, reporthook = None, data = None):
  103.     global _urlopener
  104.     if not _urlopener:
  105.         _urlopener = FancyURLopener()
  106.     
  107.     return _urlopener.retrieve(url, filename, reporthook, data)
  108.  
  109.  
  110. def urlcleanup():
  111.     if _urlopener:
  112.         _urlopener.cleanup()
  113.     
  114.  
  115.  
  116. class ContentTooShortError(IOError):
  117.     
  118.     def __init__(self, message, content):
  119.         IOError.__init__(self, message)
  120.         self.content = content
  121.  
  122.  
  123. ftpcache = { }
  124.  
  125. class URLopener:
  126.     """Class to open URLs.
  127.     This is a class rather than just a subroutine because we may need
  128.     more than one set of global protocol-specific options.
  129.     Note -- this is a base class for those who don't want the
  130.     automatic handling of errors type 302 (relocated) and 401
  131.     (authorization needed)."""
  132.     __tempfiles = None
  133.     version = 'Python-urllib/%s' % __version__
  134.     
  135.     def __init__(self, proxies = None, **x509):
  136.         if proxies is None:
  137.             proxies = getproxies()
  138.         
  139.         if not hasattr(proxies, 'has_key'):
  140.             raise AssertionError, 'proxies must be a mapping'
  141.         self.proxies = proxies
  142.         self.key_file = x509.get('key_file')
  143.         self.cert_file = x509.get('cert_file')
  144.         self.addheaders = [
  145.             ('User-Agent', self.version)]
  146.         self._URLopener__tempfiles = []
  147.         self._URLopener__unlink = os.unlink
  148.         self.tempcache = None
  149.         self.ftpcache = ftpcache
  150.  
  151.     
  152.     def __del__(self):
  153.         self.close()
  154.  
  155.     
  156.     def close(self):
  157.         self.cleanup()
  158.  
  159.     
  160.     def cleanup(self):
  161.         if self._URLopener__tempfiles:
  162.             for file in self._URLopener__tempfiles:
  163.                 
  164.                 try:
  165.                     self._URLopener__unlink(file)
  166.                 continue
  167.                 except OSError:
  168.                     continue
  169.                 
  170.  
  171.             
  172.             del self._URLopener__tempfiles[:]
  173.         
  174.         if self.tempcache:
  175.             self.tempcache.clear()
  176.         
  177.  
  178.     
  179.     def addheader(self, *args):
  180.         """Add a header to be used by the HTTP interface only
  181.         e.g. u.addheader('Accept', 'sound/basic')"""
  182.         self.addheaders.append(args)
  183.  
  184.     
  185.     def open(self, fullurl, data = None):
  186.         """Use URLopener().open(file) instead of open(file, 'r')."""
  187.         fullurl = unwrap(toBytes(fullurl))
  188.         if self.tempcache and fullurl in self.tempcache:
  189.             (filename, headers) = self.tempcache[fullurl]
  190.             fp = open(filename, 'rb')
  191.             return addinfourl(fp, headers, fullurl)
  192.         
  193.         (urltype, url) = splittype(fullurl)
  194.         if not urltype:
  195.             urltype = 'file'
  196.         
  197.         if urltype in self.proxies:
  198.             proxy = self.proxies[urltype]
  199.             (urltype, proxyhost) = splittype(proxy)
  200.             (host, selector) = splithost(proxyhost)
  201.             url = (host, fullurl)
  202.         else:
  203.             proxy = None
  204.         name = 'open_' + urltype
  205.         self.type = urltype
  206.         name = name.replace('-', '_')
  207.         if not hasattr(self, name):
  208.             if proxy:
  209.                 return self.open_unknown_proxy(proxy, fullurl, data)
  210.             else:
  211.                 return self.open_unknown(fullurl, data)
  212.         
  213.         
  214.         try:
  215.             if data is None:
  216.                 return getattr(self, name)(url)
  217.             else:
  218.                 return getattr(self, name)(url, data)
  219.         except socket.error:
  220.             msg = None
  221.             raise IOError, ('socket error', msg), sys.exc_info()[2]
  222.  
  223.  
  224.     
  225.     def open_unknown(self, fullurl, data = None):
  226.         '''Overridable interface to open unknown URL type.'''
  227.         (type, url) = splittype(fullurl)
  228.         raise IOError, ('url error', 'unknown url type', type)
  229.  
  230.     
  231.     def open_unknown_proxy(self, proxy, fullurl, data = None):
  232.         '''Overridable interface to open unknown URL type.'''
  233.         (type, url) = splittype(fullurl)
  234.         raise IOError, ('url error', 'invalid proxy for %s' % type, proxy)
  235.  
  236.     
  237.     def retrieve(self, url, filename = None, reporthook = None, data = None):
  238.         '''retrieve(url) returns (filename, headers) for a local object
  239.         or (tempfilename, headers) for a remote object.'''
  240.         url = unwrap(toBytes(url))
  241.         if self.tempcache and url in self.tempcache:
  242.             return self.tempcache[url]
  243.         
  244.         (type, url1) = splittype(url)
  245.         if filename is None:
  246.             if not type or type == 'file':
  247.                 
  248.                 try:
  249.                     fp = self.open_local_file(url1)
  250.                     hdrs = fp.info()
  251.                     del fp
  252.                     return (url2pathname(splithost(url1)[1]), hdrs)
  253.                 except IOError:
  254.                     msg = None
  255.                 except:
  256.                     None<EXCEPTION MATCH>IOError
  257.                 
  258.  
  259.         None<EXCEPTION MATCH>IOError
  260.         fp = self.open(url, data)
  261.         headers = fp.info()
  262.         if filename:
  263.             tfp = open(filename, 'wb')
  264.         else:
  265.             import tempfile as tempfile
  266.             (garbage, path) = splittype(url)
  267.             if not path:
  268.                 pass
  269.             (garbage, path) = splithost('')
  270.             if not path:
  271.                 pass
  272.             (path, garbage) = splitquery('')
  273.             if not path:
  274.                 pass
  275.             (path, garbage) = splitattr('')
  276.             suffix = os.path.splitext(path)[1]
  277.             (fd, filename) = tempfile.mkstemp(suffix)
  278.             self._URLopener__tempfiles.append(filename)
  279.             tfp = os.fdopen(fd, 'wb')
  280.         result = (filename, headers)
  281.         if self.tempcache is not None:
  282.             self.tempcache[url] = result
  283.         
  284.         bs = 8192
  285.         size = -1
  286.         read = 0
  287.         blocknum = 0
  288.         if reporthook:
  289.             if 'content-length' in headers:
  290.                 size = int(headers['Content-Length'])
  291.             
  292.             reporthook(blocknum, bs, size)
  293.         
  294.         while None:
  295.             block = fp.read(bs)
  296.             if block == '':
  297.                 break
  298.             
  299.             read += len(block)
  300.             blocknum += 1
  301.             if reporthook:
  302.                 reporthook(blocknum, bs, size)
  303.                 continue
  304.             continue
  305.             fp.close()
  306.             tfp.close()
  307.             del fp
  308.             del tfp
  309.             if size >= 0 and read < size:
  310.                 raise ContentTooShortError('retrieval incomplete: got only %i out of %i bytes' % (read, size), result)
  311.             
  312.         return result
  313.  
  314.     
  315.     def open_http(self, url, data = None):
  316.         '''Use HTTP protocol.'''
  317.         import httplib as httplib
  318.         user_passwd = None
  319.         proxy_passwd = None
  320.         if isinstance(url, str):
  321.             (host, selector) = splithost(url)
  322.             if host:
  323.                 (user_passwd, host) = splituser(host)
  324.                 host = unquote(host)
  325.             
  326.             realhost = host
  327.         else:
  328.             (host, selector) = url
  329.             (proxy_passwd, host) = splituser(host)
  330.             (urltype, rest) = splittype(selector)
  331.             url = rest
  332.             user_passwd = None
  333.             if urltype.lower() != 'http':
  334.                 realhost = None
  335.             else:
  336.                 (realhost, rest) = splithost(rest)
  337.                 if realhost:
  338.                     (user_passwd, realhost) = splituser(realhost)
  339.                 
  340.                 if user_passwd:
  341.                     selector = '%s://%s%s' % (urltype, realhost, rest)
  342.                 
  343.                 if proxy_bypass(realhost):
  344.                     host = realhost
  345.                 
  346.         if not host:
  347.             raise IOError, ('http error', 'no host given')
  348.         
  349.         if proxy_passwd:
  350.             import base64 as base64
  351.             proxy_auth = base64.b64encode(proxy_passwd).strip()
  352.         else:
  353.             proxy_auth = None
  354.         if user_passwd:
  355.             import base64 as base64
  356.             auth = base64.b64encode(user_passwd).strip()
  357.         else:
  358.             auth = None
  359.         h = httplib.HTTP(host)
  360.         if data is not None:
  361.             h.putrequest('POST', selector)
  362.             h.putheader('Content-Type', 'application/x-www-form-urlencoded')
  363.             h.putheader('Content-Length', '%d' % len(data))
  364.         else:
  365.             h.putrequest('GET', selector)
  366.         if proxy_auth:
  367.             h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth)
  368.         
  369.         if auth:
  370.             h.putheader('Authorization', 'Basic %s' % auth)
  371.         
  372.         if realhost:
  373.             h.putheader('Host', realhost)
  374.         
  375.         for args in self.addheaders:
  376.             h.putheader(*args)
  377.         
  378.         h.endheaders()
  379.         if data is not None:
  380.             h.send(data)
  381.         
  382.         (errcode, errmsg, headers) = h.getreply()
  383.         if errcode == -1:
  384.             raise IOError, ('http protocol error', 0, 'got a bad status line', None)
  385.         
  386.         fp = h.getfile()
  387.         if errcode == 200:
  388.             return addinfourl(fp, headers, 'http:' + url)
  389.         elif data is None:
  390.             return self.http_error(url, fp, errcode, errmsg, headers)
  391.         else:
  392.             return self.http_error(url, fp, errcode, errmsg, headers, data)
  393.  
  394.     
  395.     def http_error(self, url, fp, errcode, errmsg, headers, data = None):
  396.         '''Handle http errors.
  397.         Derived class can override this, or provide specific handlers
  398.         named http_error_DDD where DDD is the 3-digit error code.'''
  399.         name = 'http_error_%d' % errcode
  400.         if hasattr(self, name):
  401.             method = getattr(self, name)
  402.             if data is None:
  403.                 result = method(url, fp, errcode, errmsg, headers)
  404.             else:
  405.                 result = method(url, fp, errcode, errmsg, headers, data)
  406.             if result:
  407.                 return result
  408.             
  409.         
  410.         return self.http_error_default(url, fp, errcode, errmsg, headers)
  411.  
  412.     
  413.     def http_error_default(self, url, fp, errcode, errmsg, headers):
  414.         '''Default error handler: close the connection and raise IOError.'''
  415.         void = fp.read()
  416.         fp.close()
  417.         raise IOError, ('http error', errcode, errmsg, headers)
  418.  
  419.     if hasattr(socket, 'ssl'):
  420.         
  421.         def open_https(self, url, data = None):
  422.             '''Use HTTPS protocol.'''
  423.             import httplib
  424.             user_passwd = None
  425.             proxy_passwd = None
  426.             if isinstance(url, str):
  427.                 (host, selector) = splithost(url)
  428.                 if host:
  429.                     (user_passwd, host) = splituser(host)
  430.                     host = unquote(host)
  431.                 
  432.                 realhost = host
  433.             else:
  434.                 (host, selector) = url
  435.                 (proxy_passwd, host) = splituser(host)
  436.                 (urltype, rest) = splittype(selector)
  437.                 url = rest
  438.                 user_passwd = None
  439.                 if urltype.lower() != 'https':
  440.                     realhost = None
  441.                 else:
  442.                     (realhost, rest) = splithost(rest)
  443.                     if realhost:
  444.                         (user_passwd, realhost) = splituser(realhost)
  445.                     
  446.                     if user_passwd:
  447.                         selector = '%s://%s%s' % (urltype, realhost, rest)
  448.                     
  449.             if not host:
  450.                 raise IOError, ('https error', 'no host given')
  451.             
  452.             if proxy_passwd:
  453.                 import base64
  454.                 proxy_auth = base64.b64encode(proxy_passwd).strip()
  455.             else:
  456.                 proxy_auth = None
  457.             if user_passwd:
  458.                 import base64
  459.                 auth = base64.b64encode(user_passwd).strip()
  460.             else:
  461.                 auth = None
  462.             h = httplib.HTTPS(host, 0, key_file = self.key_file, cert_file = self.cert_file)
  463.             if data is not None:
  464.                 h.putrequest('POST', selector)
  465.                 h.putheader('Content-Type', 'application/x-www-form-urlencoded')
  466.                 h.putheader('Content-Length', '%d' % len(data))
  467.             else:
  468.                 h.putrequest('GET', selector)
  469.             if proxy_auth:
  470.                 h.putheader('Proxy-Authorization', 'Basic %s' % proxy_auth)
  471.             
  472.             if auth:
  473.                 h.putheader('Authorization', 'Basic %s' % auth)
  474.             
  475.             if realhost:
  476.                 h.putheader('Host', realhost)
  477.             
  478.             for args in self.addheaders:
  479.                 h.putheader(*args)
  480.             
  481.             h.endheaders()
  482.             if data is not None:
  483.                 h.send(data)
  484.             
  485.             (errcode, errmsg, headers) = h.getreply()
  486.             if errcode == -1:
  487.                 raise IOError, ('http protocol error', 0, 'got a bad status line', None)
  488.             
  489.             fp = h.getfile()
  490.             if errcode == 200:
  491.                 return addinfourl(fp, headers, 'https:' + url)
  492.             elif data is None:
  493.                 return self.http_error(url, fp, errcode, errmsg, headers)
  494.             else:
  495.                 return self.http_error(url, fp, errcode, errmsg, headers, data)
  496.  
  497.     
  498.     
  499.     def open_gopher(self, url):
  500.         '''Use Gopher protocol.'''
  501.         if not isinstance(url, str):
  502.             raise IOError, ('gopher error', 'proxy support for gopher protocol currently not implemented')
  503.         
  504.         import gopherlib as gopherlib
  505.         (host, selector) = splithost(url)
  506.         if not host:
  507.             raise IOError, ('gopher error', 'no host given')
  508.         
  509.         host = unquote(host)
  510.         (type, selector) = splitgophertype(selector)
  511.         (selector, query) = splitquery(selector)
  512.         selector = unquote(selector)
  513.         if query:
  514.             query = unquote(query)
  515.             fp = gopherlib.send_query(selector, query, host)
  516.         else:
  517.             fp = gopherlib.send_selector(selector, host)
  518.         return addinfourl(fp, noheaders(), 'gopher:' + url)
  519.  
  520.     
  521.     def open_file(self, url):
  522.         '''Use local file or FTP depending on form of URL.'''
  523.         if not isinstance(url, str):
  524.             raise IOError, ('file error', 'proxy support for file protocol currently not implemented')
  525.         
  526.         if url[:2] == '//' and url[2:3] != '/' and url[2:12].lower() != 'localhost/':
  527.             return self.open_ftp(url)
  528.         else:
  529.             return self.open_local_file(url)
  530.  
  531.     
  532.     def open_local_file(self, url):
  533.         '''Use local file.'''
  534.         import mimetypes as mimetypes
  535.         import mimetools as mimetools
  536.         import email.Utils as email
  537.         
  538.         try:
  539.             StringIO = StringIO
  540.             import cStringIO
  541.         except ImportError:
  542.             StringIO = StringIO
  543.             import StringIO
  544.  
  545.         (host, file) = splithost(url)
  546.         localname = url2pathname(file)
  547.         
  548.         try:
  549.             stats = os.stat(localname)
  550.         except OSError:
  551.             e = None
  552.             raise IOError(e.errno, e.strerror, e.filename)
  553.  
  554.         size = stats.st_size
  555.         modified = email.Utils.formatdate(stats.st_mtime, usegmt = True)
  556.         mtype = mimetypes.guess_type(url)[0]
  557.         if not mtype:
  558.             pass
  559.         headers = mimetools.Message(StringIO('Content-Type: %s\nContent-Length: %d\nLast-modified: %s\n' % ('text/plain', size, modified)))
  560.         if not host:
  561.             urlfile = file
  562.             if file[:1] == '/':
  563.                 urlfile = 'file://' + file
  564.             
  565.             return addinfourl(open(localname, 'rb'), headers, urlfile)
  566.         
  567.         (host, port) = splitport(host)
  568.         if not port and socket.gethostbyname(host) in (localhost(), thishost()):
  569.             urlfile = file
  570.             if file[:1] == '/':
  571.                 urlfile = 'file://' + file
  572.             
  573.             return addinfourl(open(localname, 'rb'), headers, urlfile)
  574.         
  575.         raise IOError, ('local file error', 'not on local host')
  576.  
  577.     
  578.     def open_ftp(self, url):
  579.         '''Use FTP protocol.'''
  580.         if not isinstance(url, str):
  581.             raise IOError, ('ftp error', 'proxy support for ftp protocol currently not implemented')
  582.         
  583.         import mimetypes
  584.         import mimetools
  585.         
  586.         try:
  587.             StringIO = StringIO
  588.             import cStringIO
  589.         except ImportError:
  590.             StringIO = StringIO
  591.             import StringIO
  592.  
  593.         (host, path) = splithost(url)
  594.         if not host:
  595.             raise IOError, ('ftp error', 'no host given')
  596.         
  597.         (host, port) = splitport(host)
  598.         (user, host) = splituser(host)
  599.         if user:
  600.             (user, passwd) = splitpasswd(user)
  601.         else:
  602.             passwd = None
  603.         host = unquote(host)
  604.         if not user:
  605.             pass
  606.         user = unquote('')
  607.         if not passwd:
  608.             pass
  609.         passwd = unquote('')
  610.         host = socket.gethostbyname(host)
  611.         if not port:
  612.             import ftplib as ftplib
  613.             port = ftplib.FTP_PORT
  614.         else:
  615.             port = int(port)
  616.         (path, attrs) = splitattr(path)
  617.         path = unquote(path)
  618.         dirs = path.split('/')
  619.         dirs = dirs[:-1]
  620.         file = dirs[-1]
  621.         if dirs and not dirs[0]:
  622.             dirs = dirs[1:]
  623.         
  624.         if dirs and not dirs[0]:
  625.             dirs[0] = '/'
  626.         
  627.         key = (user, host, port, '/'.join(dirs))
  628.         if len(self.ftpcache) > MAXFTPCACHE:
  629.             for k in self.ftpcache.keys():
  630.                 if k != key:
  631.                     v = self.ftpcache[k]
  632.                     del self.ftpcache[k]
  633.                     v.close()
  634.                     continue
  635.             
  636.         
  637.         
  638.         try:
  639.             if key not in self.ftpcache:
  640.                 self.ftpcache[key] = ftpwrapper(user, passwd, host, port, dirs)
  641.             
  642.             if not file:
  643.                 type = 'D'
  644.             else:
  645.                 type = 'I'
  646.             for attr in attrs:
  647.                 (attr, value) = splitvalue(attr)
  648.                 if attr.lower() == 'type' and value in ('a', 'A', 'i', 'I', 'd', 'D'):
  649.                     type = value.upper()
  650.                     continue
  651.             
  652.             (fp, retrlen) = self.ftpcache[key].retrfile(file, type)
  653.             mtype = mimetypes.guess_type('ftp:' + url)[0]
  654.             headers = ''
  655.             if mtype:
  656.                 headers += 'Content-Type: %s\n' % mtype
  657.             
  658.             if retrlen is not None and retrlen >= 0:
  659.                 headers += 'Content-Length: %d\n' % retrlen
  660.             
  661.             headers = mimetools.Message(StringIO(headers))
  662.             return addinfourl(fp, headers, 'ftp:' + url)
  663.         except ftperrors():
  664.             msg = None
  665.             raise IOError, ('ftp error', msg), sys.exc_info()[2]
  666.  
  667.  
  668.     
  669.     def open_data(self, url, data = None):
  670.         '''Use "data" URL.'''
  671.         if not isinstance(url, str):
  672.             raise IOError, ('data error', 'proxy support for data protocol currently not implemented')
  673.         
  674.         import mimetools
  675.         
  676.         try:
  677.             StringIO = StringIO
  678.             import cStringIO
  679.         except ImportError:
  680.             StringIO = StringIO
  681.             import StringIO
  682.  
  683.         
  684.         try:
  685.             (type, data) = url.split(',', 1)
  686.         except ValueError:
  687.             raise IOError, ('data error', 'bad data URL')
  688.  
  689.         if not type:
  690.             type = 'text/plain;charset=US-ASCII'
  691.         
  692.         semi = type.rfind(';')
  693.         if semi >= 0 and '=' not in type[semi:]:
  694.             encoding = type[semi + 1:]
  695.             type = type[:semi]
  696.         else:
  697.             encoding = ''
  698.         msg = []
  699.         msg.append('Date: %s' % time.strftime('%a, %d %b %Y %T GMT', time.gmtime(time.time())))
  700.         msg.append('Content-type: %s' % type)
  701.         if encoding == 'base64':
  702.             import base64
  703.             data = base64.decodestring(data)
  704.         else:
  705.             data = unquote(data)
  706.         msg.append('Content-Length: %d' % len(data))
  707.         msg.append('')
  708.         msg.append(data)
  709.         msg = '\n'.join(msg)
  710.         f = StringIO(msg)
  711.         headers = mimetools.Message(f, 0)
  712.         return addinfourl(f, headers, url)
  713.  
  714.  
  715.  
  716. class FancyURLopener(URLopener):
  717.     '''Derived class with handlers for errors we can handle (perhaps).'''
  718.     
  719.     def __init__(self, *args, **kwargs):
  720.         URLopener.__init__(self, *args, **kwargs)
  721.         self.auth_cache = { }
  722.         self.tries = 0
  723.         self.maxtries = 10
  724.  
  725.     
  726.     def http_error_default(self, url, fp, errcode, errmsg, headers):
  727.         """Default error handling -- don't raise an exception."""
  728.         return addinfourl(fp, headers, 'http:' + url)
  729.  
  730.     
  731.     def http_error_302(self, url, fp, errcode, errmsg, headers, data = None):
  732.         '''Error 302 -- relocated (temporarily).'''
  733.         self.tries += 1
  734.         result = self.redirect_internal(url, fp, errcode, errmsg, headers, data)
  735.         self.tries = 0
  736.         return result
  737.  
  738.     
  739.     def redirect_internal(self, url, fp, errcode, errmsg, headers, data):
  740.         if 'location' in headers:
  741.             newurl = headers['location']
  742.         elif 'uri' in headers:
  743.             newurl = headers['uri']
  744.         else:
  745.             return None
  746.         void = fp.read()
  747.         fp.close()
  748.         newurl = basejoin(self.type + ':' + url, newurl)
  749.         return self.open(newurl)
  750.  
  751.     
  752.     def http_error_301(self, url, fp, errcode, errmsg, headers, data = None):
  753.         '''Error 301 -- also relocated (permanently).'''
  754.         return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  755.  
  756.     
  757.     def http_error_303(self, url, fp, errcode, errmsg, headers, data = None):
  758.         '''Error 303 -- also relocated (essentially identical to 302).'''
  759.         return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  760.  
  761.     
  762.     def http_error_307(self, url, fp, errcode, errmsg, headers, data = None):
  763.         '''Error 307 -- relocated, but turn POST into error.'''
  764.         if data is None:
  765.             return self.http_error_302(url, fp, errcode, errmsg, headers, data)
  766.         else:
  767.             return self.http_error_default(url, fp, errcode, errmsg, headers)
  768.  
  769.     
  770.     def http_error_401(self, url, fp, errcode, errmsg, headers, data = None):
  771.         '''Error 401 -- authentication required.
  772.         This function supports Basic authentication only.'''
  773.         if 'www-authenticate' not in headers:
  774.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  775.         
  776.         stuff = headers['www-authenticate']
  777.         import re as re
  778.         match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
  779.         if not match:
  780.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  781.         
  782.         (scheme, realm) = match.groups()
  783.         if scheme.lower() != 'basic':
  784.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  785.         
  786.         name = 'retry_' + self.type + '_basic_auth'
  787.         if data is None:
  788.             return getattr(self, name)(url, realm)
  789.         else:
  790.             return getattr(self, name)(url, realm, data)
  791.  
  792.     
  793.     def http_error_407(self, url, fp, errcode, errmsg, headers, data = None):
  794.         '''Error 407 -- proxy authentication required.
  795.         This function supports Basic authentication only.'''
  796.         if 'proxy-authenticate' not in headers:
  797.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  798.         
  799.         stuff = headers['proxy-authenticate']
  800.         import re
  801.         match = re.match('[ \t]*([^ \t]+)[ \t]+realm="([^"]*)"', stuff)
  802.         if not match:
  803.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  804.         
  805.         (scheme, realm) = match.groups()
  806.         if scheme.lower() != 'basic':
  807.             URLopener.http_error_default(self, url, fp, errcode, errmsg, headers)
  808.         
  809.         name = 'retry_proxy_' + self.type + '_basic_auth'
  810.         if data is None:
  811.             return getattr(self, name)(url, realm)
  812.         else:
  813.             return getattr(self, name)(url, realm, data)
  814.  
  815.     
  816.     def retry_proxy_http_basic_auth(self, url, realm, data = None):
  817.         (host, selector) = splithost(url)
  818.         newurl = 'http://' + host + selector
  819.         proxy = self.proxies['http']
  820.         (urltype, proxyhost) = splittype(proxy)
  821.         (proxyhost, proxyselector) = splithost(proxyhost)
  822.         i = proxyhost.find('@') + 1
  823.         proxyhost = proxyhost[i:]
  824.         (user, passwd) = self.get_user_passwd(proxyhost, realm, i)
  825.         if not user or passwd:
  826.             return None
  827.         
  828.         proxyhost = quote(user, safe = '') + ':' + quote(passwd, safe = '') + '@' + proxyhost
  829.         self.proxies['http'] = 'http://' + proxyhost + proxyselector
  830.         if data is None:
  831.             return self.open(newurl)
  832.         else:
  833.             return self.open(newurl, data)
  834.  
  835.     
  836.     def retry_proxy_https_basic_auth(self, url, realm, data = None):
  837.         (host, selector) = splithost(url)
  838.         newurl = 'https://' + host + selector
  839.         proxy = self.proxies['https']
  840.         (urltype, proxyhost) = splittype(proxy)
  841.         (proxyhost, proxyselector) = splithost(proxyhost)
  842.         i = proxyhost.find('@') + 1
  843.         proxyhost = proxyhost[i:]
  844.         (user, passwd) = self.get_user_passwd(proxyhost, realm, i)
  845.         if not user or passwd:
  846.             return None
  847.         
  848.         proxyhost = quote(user, safe = '') + ':' + quote(passwd, safe = '') + '@' + proxyhost
  849.         self.proxies['https'] = 'https://' + proxyhost + proxyselector
  850.         if data is None:
  851.             return self.open(newurl)
  852.         else:
  853.             return self.open(newurl, data)
  854.  
  855.     
  856.     def retry_http_basic_auth(self, url, realm, data = None):
  857.         (host, selector) = splithost(url)
  858.         i = host.find('@') + 1
  859.         host = host[i:]
  860.         (user, passwd) = self.get_user_passwd(host, realm, i)
  861.         if not user or passwd:
  862.             return None
  863.         
  864.         host = quote(user, safe = '') + ':' + quote(passwd, safe = '') + '@' + host
  865.         newurl = 'http://' + host + selector
  866.         if data is None:
  867.             return self.open(newurl)
  868.         else:
  869.             return self.open(newurl, data)
  870.  
  871.     
  872.     def retry_https_basic_auth(self, url, realm, data = None):
  873.         (host, selector) = splithost(url)
  874.         i = host.find('@') + 1
  875.         host = host[i:]
  876.         (user, passwd) = self.get_user_passwd(host, realm, i)
  877.         if not user or passwd:
  878.             return None
  879.         
  880.         host = quote(user, safe = '') + ':' + quote(passwd, safe = '') + '@' + host
  881.         newurl = 'https://' + host + selector
  882.         if data is None:
  883.             return self.open(newurl)
  884.         else:
  885.             return self.open(newurl, data)
  886.  
  887.     
  888.     def get_user_passwd(self, host, realm, clear_cache = 0):
  889.         key = realm + '@' + host.lower()
  890.         if key in self.auth_cache:
  891.             if clear_cache:
  892.                 del self.auth_cache[key]
  893.             else:
  894.                 return self.auth_cache[key]
  895.         
  896.         (user, passwd) = self.prompt_user_passwd(host, realm)
  897.         if user or passwd:
  898.             self.auth_cache[key] = (user, passwd)
  899.         
  900.         return (user, passwd)
  901.  
  902.     
  903.     def prompt_user_passwd(self, host, realm):
  904.         '''Override this in a GUI environment!'''
  905.         import getpass as getpass
  906.         
  907.         try:
  908.             user = raw_input('Enter username for %s at %s: ' % (realm, host))
  909.             passwd = getpass.getpass('Enter password for %s in %s at %s: ' % (user, realm, host))
  910.             return (user, passwd)
  911.         except KeyboardInterrupt:
  912.             print 
  913.             return (None, None)
  914.  
  915.  
  916.  
  917. _localhost = None
  918.  
  919. def localhost():
  920.     """Return the IP address of the magic hostname 'localhost'."""
  921.     global _localhost
  922.     if _localhost is None:
  923.         _localhost = socket.gethostbyname('localhost')
  924.     
  925.     return _localhost
  926.  
  927. _thishost = None
  928.  
  929. def thishost():
  930.     '''Return the IP address of the current host.'''
  931.     global _thishost
  932.     if _thishost is None:
  933.         _thishost = socket.gethostbyname(socket.gethostname())
  934.     
  935.     return _thishost
  936.  
  937. _ftperrors = None
  938.  
  939. def ftperrors():
  940.     '''Return the set of errors raised by the FTP class.'''
  941.     global _ftperrors
  942.     if _ftperrors is None:
  943.         import ftplib
  944.         _ftperrors = ftplib.all_errors
  945.     
  946.     return _ftperrors
  947.  
  948. _noheaders = None
  949.  
  950. def noheaders():
  951.     '''Return an empty mimetools.Message object.'''
  952.     global _noheaders
  953.     if _noheaders is None:
  954.         import mimetools
  955.         
  956.         try:
  957.             StringIO = StringIO
  958.             import cStringIO
  959.         except ImportError:
  960.             StringIO = StringIO
  961.             import StringIO
  962.  
  963.         _noheaders = mimetools.Message(StringIO(), 0)
  964.         _noheaders.fp.close()
  965.     
  966.     return _noheaders
  967.  
  968.  
  969. class ftpwrapper:
  970.     '''Class used by open_ftp() for cache of open FTP connections.'''
  971.     
  972.     def __init__(self, user, passwd, host, port, dirs):
  973.         self.user = user
  974.         self.passwd = passwd
  975.         self.host = host
  976.         self.port = port
  977.         self.dirs = dirs
  978.         self.init()
  979.  
  980.     
  981.     def init(self):
  982.         import ftplib
  983.         self.busy = 0
  984.         self.ftp = ftplib.FTP()
  985.         self.ftp.connect(self.host, self.port)
  986.         self.ftp.login(self.user, self.passwd)
  987.         for dir in self.dirs:
  988.             self.ftp.cwd(dir)
  989.         
  990.  
  991.     
  992.     def retrfile(self, file, type):
  993.         import ftplib
  994.         self.endtransfer()
  995.         if type in ('d', 'D'):
  996.             cmd = 'TYPE A'
  997.             isdir = 1
  998.         else:
  999.             cmd = 'TYPE ' + type
  1000.             isdir = 0
  1001.         
  1002.         try:
  1003.             self.ftp.voidcmd(cmd)
  1004.         except ftplib.all_errors:
  1005.             self.init()
  1006.             self.ftp.voidcmd(cmd)
  1007.  
  1008.         conn = None
  1009.         if file and not isdir:
  1010.             
  1011.             try:
  1012.                 cmd = 'RETR ' + file
  1013.                 conn = self.ftp.ntransfercmd(cmd)
  1014.             except ftplib.error_perm:
  1015.                 reason = None
  1016.                 if str(reason)[:3] != '550':
  1017.                     raise IOError, ('ftp error', reason), sys.exc_info()[2]
  1018.                 
  1019.             except:
  1020.                 str(reason)[:3] != '550'
  1021.             
  1022.  
  1023.         None<EXCEPTION MATCH>ftplib.error_perm
  1024.         if not conn:
  1025.             self.ftp.voidcmd('TYPE A')
  1026.             if file:
  1027.                 cmd = 'LIST ' + file
  1028.             else:
  1029.                 cmd = 'LIST'
  1030.             conn = self.ftp.ntransfercmd(cmd)
  1031.         
  1032.         self.busy = 1
  1033.         return (addclosehook(conn[0].makefile('rb'), self.endtransfer), conn[1])
  1034.  
  1035.     
  1036.     def endtransfer(self):
  1037.         if not self.busy:
  1038.             return None
  1039.         
  1040.         self.busy = 0
  1041.         
  1042.         try:
  1043.             self.ftp.voidresp()
  1044.         except ftperrors():
  1045.             pass
  1046.  
  1047.  
  1048.     
  1049.     def close(self):
  1050.         self.endtransfer()
  1051.         
  1052.         try:
  1053.             self.ftp.close()
  1054.         except ftperrors():
  1055.             pass
  1056.  
  1057.  
  1058.  
  1059.  
  1060. class addbase:
  1061.     '''Base class for addinfo and addclosehook.'''
  1062.     
  1063.     def __init__(self, fp):
  1064.         self.fp = fp
  1065.         self.read = self.fp.read
  1066.         self.readline = self.fp.readline
  1067.         if hasattr(self.fp, 'readlines'):
  1068.             self.readlines = self.fp.readlines
  1069.         
  1070.         if hasattr(self.fp, 'fileno'):
  1071.             self.fileno = self.fp.fileno
  1072.         else:
  1073.             
  1074.             self.fileno = lambda : pass
  1075.         if hasattr(self.fp, '__iter__'):
  1076.             self.__iter__ = self.fp.__iter__
  1077.             if hasattr(self.fp, 'next'):
  1078.                 self.next = self.fp.next
  1079.             
  1080.         
  1081.  
  1082.     
  1083.     def __repr__(self):
  1084.         return '<%s at %r whose fp = %r>' % (self.__class__.__name__, id(self), self.fp)
  1085.  
  1086.     
  1087.     def close(self):
  1088.         self.read = None
  1089.         self.readline = None
  1090.         self.readlines = None
  1091.         self.fileno = None
  1092.         if self.fp:
  1093.             self.fp.close()
  1094.         
  1095.         self.fp = None
  1096.  
  1097.  
  1098.  
  1099. class addclosehook(addbase):
  1100.     '''Class to add a close hook to an open file.'''
  1101.     
  1102.     def __init__(self, fp, closehook, *hookargs):
  1103.         addbase.__init__(self, fp)
  1104.         self.closehook = closehook
  1105.         self.hookargs = hookargs
  1106.  
  1107.     
  1108.     def close(self):
  1109.         addbase.close(self)
  1110.         if self.closehook:
  1111.             self.closehook(*self.hookargs)
  1112.             self.closehook = None
  1113.             self.hookargs = None
  1114.         
  1115.  
  1116.  
  1117.  
  1118. class addinfo(addbase):
  1119.     '''class to add an info() method to an open file.'''
  1120.     
  1121.     def __init__(self, fp, headers):
  1122.         addbase.__init__(self, fp)
  1123.         self.headers = headers
  1124.  
  1125.     
  1126.     def info(self):
  1127.         return self.headers
  1128.  
  1129.  
  1130.  
  1131. class addinfourl(addbase):
  1132.     '''class to add info() and geturl() methods to an open file.'''
  1133.     
  1134.     def __init__(self, fp, headers, url):
  1135.         addbase.__init__(self, fp)
  1136.         self.headers = headers
  1137.         self.url = url
  1138.  
  1139.     
  1140.     def info(self):
  1141.         return self.headers
  1142.  
  1143.     
  1144.     def geturl(self):
  1145.         return self.url
  1146.  
  1147.  
  1148.  
  1149. try:
  1150.     unicode
  1151. except NameError:
  1152.     
  1153.     def _is_unicode(x):
  1154.         return 0
  1155.  
  1156.  
  1157.  
  1158. def _is_unicode(x):
  1159.     return isinstance(x, unicode)
  1160.  
  1161.  
  1162. def toBytes(url):
  1163.     '''toBytes(u"URL") --> \'URL\'.'''
  1164.     if _is_unicode(url):
  1165.         
  1166.         try:
  1167.             url = url.encode('ASCII')
  1168.         except UnicodeError:
  1169.             raise UnicodeError('URL ' + repr(url) + ' contains non-ASCII characters')
  1170.         except:
  1171.             None<EXCEPTION MATCH>UnicodeError
  1172.         
  1173.  
  1174.     None<EXCEPTION MATCH>UnicodeError
  1175.     return url
  1176.  
  1177.  
  1178. def unwrap(url):
  1179.     """unwrap('<URL:type://host/path>') --> 'type://host/path'."""
  1180.     url = url.strip()
  1181.     if url[:1] == '<' and url[-1:] == '>':
  1182.         url = url[1:-1].strip()
  1183.     
  1184.     if url[:4] == 'URL:':
  1185.         url = url[4:].strip()
  1186.     
  1187.     return url
  1188.  
  1189. _typeprog = None
  1190.  
  1191. def splittype(url):
  1192.     """splittype('type:opaquestring') --> 'type', 'opaquestring'."""
  1193.     global _typeprog
  1194.     if _typeprog is None:
  1195.         import re
  1196.         _typeprog = re.compile('^([^/:]+):')
  1197.     
  1198.     match = _typeprog.match(url)
  1199.     if match:
  1200.         scheme = match.group(1)
  1201.         return (scheme.lower(), url[len(scheme) + 1:])
  1202.     
  1203.     return (None, url)
  1204.  
  1205. _hostprog = None
  1206.  
  1207. def splithost(url):
  1208.     """splithost('//host[:port]/path') --> 'host[:port]', '/path'."""
  1209.     global _hostprog
  1210.     if _hostprog is None:
  1211.         import re
  1212.         _hostprog = re.compile('^//([^/?]*)(.*)$')
  1213.     
  1214.     match = _hostprog.match(url)
  1215.     if match:
  1216.         return match.group(1, 2)
  1217.     
  1218.     return (None, url)
  1219.  
  1220. _userprog = None
  1221.  
  1222. def splituser(host):
  1223.     """splituser('user[:passwd]@host[:port]') --> 'user[:passwd]', 'host[:port]'."""
  1224.     global _userprog
  1225.     if _userprog is None:
  1226.         import re
  1227.         _userprog = re.compile('^(.*)@(.*)$')
  1228.     
  1229.     match = _userprog.match(host)
  1230.     if match:
  1231.         return map(unquote, match.group(1, 2))
  1232.     
  1233.     return (None, host)
  1234.  
  1235. _passwdprog = None
  1236.  
  1237. def splitpasswd(user):
  1238.     """splitpasswd('user:passwd') -> 'user', 'passwd'."""
  1239.     global _passwdprog
  1240.     if _passwdprog is None:
  1241.         import re
  1242.         _passwdprog = re.compile('^([^:]*):(.*)$')
  1243.     
  1244.     match = _passwdprog.match(user)
  1245.     if match:
  1246.         return match.group(1, 2)
  1247.     
  1248.     return (user, None)
  1249.  
  1250. _portprog = None
  1251.  
  1252. def splitport(host):
  1253.     """splitport('host:port') --> 'host', 'port'."""
  1254.     global _portprog
  1255.     if _portprog is None:
  1256.         import re
  1257.         _portprog = re.compile('^(.*):([0-9]+)$')
  1258.     
  1259.     match = _portprog.match(host)
  1260.     if match:
  1261.         return match.group(1, 2)
  1262.     
  1263.     return (host, None)
  1264.  
  1265. _nportprog = None
  1266.  
  1267. def splitnport(host, defport = -1):
  1268.     """Split host and port, returning numeric port.
  1269.     Return given default port if no ':' found; defaults to -1.
  1270.     Return numerical port if a valid number are found after ':'.
  1271.     Return None if ':' but not a valid number."""
  1272.     global _nportprog
  1273.     if _nportprog is None:
  1274.         import re
  1275.         _nportprog = re.compile('^(.*):(.*)$')
  1276.     
  1277.     match = _nportprog.match(host)
  1278.     if match:
  1279.         (host, port) = match.group(1, 2)
  1280.         
  1281.         try:
  1282.             if not port:
  1283.                 raise ValueError, 'no digits'
  1284.             
  1285.             nport = int(port)
  1286.         except ValueError:
  1287.             nport = None
  1288.  
  1289.         return (host, nport)
  1290.     
  1291.     return (host, defport)
  1292.  
  1293. _queryprog = None
  1294.  
  1295. def splitquery(url):
  1296.     """splitquery('/path?query') --> '/path', 'query'."""
  1297.     global _queryprog
  1298.     if _queryprog is None:
  1299.         import re
  1300.         _queryprog = re.compile('^(.*)\\?([^?]*)$')
  1301.     
  1302.     match = _queryprog.match(url)
  1303.     if match:
  1304.         return match.group(1, 2)
  1305.     
  1306.     return (url, None)
  1307.  
  1308. _tagprog = None
  1309.  
  1310. def splittag(url):
  1311.     """splittag('/path#tag') --> '/path', 'tag'."""
  1312.     global _tagprog
  1313.     if _tagprog is None:
  1314.         import re
  1315.         _tagprog = re.compile('^(.*)#([^#]*)$')
  1316.     
  1317.     match = _tagprog.match(url)
  1318.     if match:
  1319.         return match.group(1, 2)
  1320.     
  1321.     return (url, None)
  1322.  
  1323.  
  1324. def splitattr(url):
  1325.     """splitattr('/path;attr1=value1;attr2=value2;...') ->
  1326.         '/path', ['attr1=value1', 'attr2=value2', ...]."""
  1327.     words = url.split(';')
  1328.     return (words[0], words[1:])
  1329.  
  1330. _valueprog = None
  1331.  
  1332. def splitvalue(attr):
  1333.     """splitvalue('attr=value') --> 'attr', 'value'."""
  1334.     global _valueprog
  1335.     if _valueprog is None:
  1336.         import re
  1337.         _valueprog = re.compile('^([^=]*)=(.*)$')
  1338.     
  1339.     match = _valueprog.match(attr)
  1340.     if match:
  1341.         return match.group(1, 2)
  1342.     
  1343.     return (attr, None)
  1344.  
  1345.  
  1346. def splitgophertype(selector):
  1347.     """splitgophertype('/Xselector') --> 'X', 'selector'."""
  1348.     if selector[:1] == '/' and selector[1:2]:
  1349.         return (selector[1], selector[2:])
  1350.     
  1351.     return (None, selector)
  1352.  
  1353. _hextochr = dict((lambda .0: for i in .0:
  1354. ('%02x' % i, chr(i)))(range(256)))
  1355. _hextochr.update((lambda .0: for i in .0:
  1356. ('%02X' % i, chr(i)))(range(256)))
  1357.  
  1358. def unquote(s):
  1359.     """unquote('abc%20def') -> 'abc def'."""
  1360.     res = s.split('%')
  1361.     for i in xrange(1, len(res)):
  1362.         item = res[i]
  1363.         
  1364.         try:
  1365.             res[i] = _hextochr[item[:2]] + item[2:]
  1366.         continue
  1367.         except KeyError:
  1368.             res[i] = '%' + item
  1369.             continue
  1370.             except UnicodeDecodeError:
  1371.                 res[i] = unichr(int(item[:2], 16)) + item[2:]
  1372.                 continue
  1373.             
  1374.         return ''.join(res)
  1375.  
  1376.  
  1377.  
  1378. def unquote_plus(s):
  1379.     """unquote('%7e/abc+def') -> '~/abc def'"""
  1380.     s = s.replace('+', ' ')
  1381.     return unquote(s)
  1382.  
  1383. always_safe = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_.-'
  1384. _safemaps = { }
  1385.  
  1386. def quote(s, safe = '/'):
  1387.     '''quote(\'abc def\') -> \'abc%20def\'
  1388.  
  1389.     Each part of a URL, e.g. the path info, the query, etc., has a
  1390.     different set of reserved characters that must be quoted.
  1391.  
  1392.     RFC 2396 Uniform Resource Identifiers (URI): Generic Syntax lists
  1393.     the following reserved characters.
  1394.  
  1395.     reserved    = ";" | "/" | "?" | ":" | "@" | "&" | "=" | "+" |
  1396.                   "$" | ","
  1397.  
  1398.     Each of these characters is reserved in some component of a URL,
  1399.     but not necessarily in all of them.
  1400.  
  1401.     By default, the quote function is intended for quoting the path
  1402.     section of a URL.  Thus, it will not encode \'/\'.  This character
  1403.     is reserved, but in typical usage the quote function is being
  1404.     called on a path where the existing slash characters are used as
  1405.     reserved characters.
  1406.     '''
  1407.     cachekey = (safe, always_safe)
  1408.     
  1409.     try:
  1410.         safe_map = _safemaps[cachekey]
  1411.     except KeyError:
  1412.         safe += always_safe
  1413.         safe_map = { }
  1414.         for i in range(256):
  1415.             c = chr(i)
  1416.             if not c in safe or c:
  1417.                 pass
  1418.             safe_map[c] = '%%%02X' % i
  1419.         
  1420.         _safemaps[cachekey] = safe_map
  1421.  
  1422.     res = map(safe_map.__getitem__, s)
  1423.     return ''.join(res)
  1424.  
  1425.  
  1426. def quote_plus(s, safe = ''):
  1427.     """Quote the query fragment of a URL; replacing ' ' with '+'"""
  1428.     if ' ' in s:
  1429.         s = quote(s, safe + ' ')
  1430.         return s.replace(' ', '+')
  1431.     
  1432.     return quote(s, safe)
  1433.  
  1434.  
  1435. def urlencode(query, doseq = 0):
  1436.     '''Encode a sequence of two-element tuples or dictionary into a URL query string.
  1437.  
  1438.     If any values in the query arg are sequences and doseq is true, each
  1439.     sequence element is converted to a separate parameter.
  1440.  
  1441.     If the query arg is a sequence of two-element tuples, the order of the
  1442.     parameters in the output will match the order of parameters in the
  1443.     input.
  1444.     '''
  1445.     if hasattr(query, 'items'):
  1446.         query = query.items()
  1447.     else:
  1448.         
  1449.         try:
  1450.             if len(query) and not isinstance(query[0], tuple):
  1451.                 raise TypeError
  1452.         except TypeError:
  1453.             (ty, va, tb) = sys.exc_info()
  1454.             raise TypeError, 'not a valid non-string sequence or mapping object', tb
  1455.  
  1456.     l = []
  1457.     if not doseq:
  1458.         for k, v in query:
  1459.             k = quote_plus(str(k))
  1460.             v = quote_plus(str(v))
  1461.             l.append(k + '=' + v)
  1462.         
  1463.     else:
  1464.         for k, v in query:
  1465.             k = quote_plus(str(k))
  1466.             if isinstance(v, str):
  1467.                 v = quote_plus(v)
  1468.                 l.append(k + '=' + v)
  1469.                 continue
  1470.             if _is_unicode(v):
  1471.                 v = quote_plus(v.encode('ASCII', 'replace'))
  1472.                 l.append(k + '=' + v)
  1473.                 continue
  1474.             
  1475.             try:
  1476.                 x = len(v)
  1477.             except TypeError:
  1478.                 v = quote_plus(str(v))
  1479.                 l.append(k + '=' + v)
  1480.                 continue
  1481.  
  1482.             for elt in v:
  1483.                 l.append(k + '=' + quote_plus(str(elt)))
  1484.             
  1485.         
  1486.     return '&'.join(l)
  1487.  
  1488.  
  1489. def getproxies_environment():
  1490.     '''Return a dictionary of scheme -> proxy server URL mappings.
  1491.  
  1492.     Scan the environment for variables named <scheme>_proxy;
  1493.     this seems to be the standard convention.  If you need a
  1494.     different way, you can pass a proxies dictionary to the
  1495.     [Fancy]URLopener constructor.
  1496.  
  1497.     '''
  1498.     proxies = { }
  1499.     for name, value in os.environ.items():
  1500.         name = name.lower()
  1501.         if value and name[-6:] == '_proxy':
  1502.             proxies[name[:-6]] = value
  1503.             continue
  1504.     
  1505.     return proxies
  1506.  
  1507. if sys.platform == 'darwin':
  1508.     
  1509.     def getproxies_internetconfig():
  1510.         '''Return a dictionary of scheme -> proxy server URL mappings.
  1511.  
  1512.         By convention the mac uses Internet Config to store
  1513.         proxies.  An HTTP proxy, for instance, is stored under
  1514.         the HttpProxy key.
  1515.  
  1516.         '''
  1517.         
  1518.         try:
  1519.             import ic as ic
  1520.         except ImportError:
  1521.             return { }
  1522.  
  1523.         
  1524.         try:
  1525.             config = ic.IC()
  1526.         except ic.error:
  1527.             return { }
  1528.  
  1529.         proxies = { }
  1530.         if 'UseHTTPProxy' in config and config['UseHTTPProxy']:
  1531.             
  1532.             try:
  1533.                 value = config['HTTPProxyHost']
  1534.             except ic.error:
  1535.                 pass
  1536.  
  1537.             proxies['http'] = 'http://%s' % value
  1538.         
  1539.         return proxies
  1540.  
  1541.     
  1542.     def proxy_bypass(x):
  1543.         return 0
  1544.  
  1545.     
  1546.     def getproxies():
  1547.         if not getproxies_environment():
  1548.             pass
  1549.         return getproxies_internetconfig()
  1550.  
  1551. elif os.name == 'nt':
  1552.     
  1553.     def getproxies_registry():
  1554.         '''Return a dictionary of scheme -> proxy server URL mappings.
  1555.  
  1556.         Win32 uses the registry to store proxies.
  1557.  
  1558.         '''
  1559.         proxies = { }
  1560.         
  1561.         try:
  1562.             import _winreg as _winreg
  1563.         except ImportError:
  1564.             return proxies
  1565.  
  1566.         
  1567.         try:
  1568.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings')
  1569.             proxyEnable = _winreg.QueryValueEx(internetSettings, 'ProxyEnable')[0]
  1570.             if proxyEnable:
  1571.                 proxyServer = str(_winreg.QueryValueEx(internetSettings, 'ProxyServer')[0])
  1572.                 if '=' in proxyServer:
  1573.                     for p in proxyServer.split(';'):
  1574.                         (protocol, address) = p.split('=', 1)
  1575.                         import re
  1576.                         if not re.match('^([^/:]+)://', address):
  1577.                             address = '%s://%s' % (protocol, address)
  1578.                         
  1579.                         proxies[protocol] = address
  1580.                     
  1581.                 elif proxyServer[:5] == 'http:':
  1582.                     proxies['http'] = proxyServer
  1583.                 else:
  1584.                     proxies['http'] = 'http://%s' % proxyServer
  1585.                     proxies['ftp'] = 'ftp://%s' % proxyServer
  1586.             
  1587.             internetSettings.Close()
  1588.         except (WindowsError, ValueError, TypeError):
  1589.             pass
  1590.  
  1591.         return proxies
  1592.  
  1593.     
  1594.     def getproxies():
  1595.         '''Return a dictionary of scheme -> proxy server URL mappings.
  1596.  
  1597.         Returns settings gathered from the environment, if specified,
  1598.         or the registry.
  1599.  
  1600.         '''
  1601.         if not getproxies_environment():
  1602.             pass
  1603.         return getproxies_registry()
  1604.  
  1605.     
  1606.     def proxy_bypass(host):
  1607.         
  1608.         try:
  1609.             import _winreg
  1610.             import re
  1611.         except ImportError:
  1612.             return 0
  1613.  
  1614.         
  1615.         try:
  1616.             internetSettings = _winreg.OpenKey(_winreg.HKEY_CURRENT_USER, 'Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings')
  1617.             proxyEnable = _winreg.QueryValueEx(internetSettings, 'ProxyEnable')[0]
  1618.             proxyOverride = str(_winreg.QueryValueEx(internetSettings, 'ProxyOverride')[0])
  1619.         except WindowsError:
  1620.             return 0
  1621.  
  1622.         if not proxyEnable or not proxyOverride:
  1623.             return 0
  1624.         
  1625.         (rawHost, port) = splitport(host)
  1626.         host = [
  1627.             rawHost]
  1628.         
  1629.         try:
  1630.             addr = socket.gethostbyname(rawHost)
  1631.             if addr != rawHost:
  1632.                 host.append(addr)
  1633.         except socket.error:
  1634.             pass
  1635.  
  1636.         
  1637.         try:
  1638.             fqdn = socket.getfqdn(rawHost)
  1639.             if fqdn != rawHost:
  1640.                 host.append(fqdn)
  1641.         except socket.error:
  1642.             pass
  1643.  
  1644.         proxyOverride = proxyOverride.split(';')
  1645.         i = 0
  1646.         while i < len(proxyOverride):
  1647.             if proxyOverride[i] == '<local>':
  1648.                 proxyOverride[i:i + 1] = [
  1649.                     'localhost',
  1650.                     '127.0.0.1',
  1651.                     socket.gethostname(),
  1652.                     socket.gethostbyname(socket.gethostname())]
  1653.             
  1654.             i += 1
  1655.         for test in proxyOverride:
  1656.             test = test.replace('.', '\\.')
  1657.             test = test.replace('*', '.*')
  1658.             test = test.replace('?', '.')
  1659.             for val in host:
  1660.                 if re.match(test, val, re.I):
  1661.                     return 1
  1662.                     continue
  1663.             
  1664.         
  1665.         return 0
  1666.  
  1667. else:
  1668.     getproxies = getproxies_environment
  1669.     
  1670.     def proxy_bypass(host):
  1671.         return 0
  1672.  
  1673.  
  1674. def test1():
  1675.     s = ''
  1676.     for i in range(256):
  1677.         s = s + chr(i)
  1678.     
  1679.     s = s * 4
  1680.     t0 = time.time()
  1681.     qs = quote(s)
  1682.     uqs = unquote(qs)
  1683.     t1 = time.time()
  1684.     if uqs != s:
  1685.         print 'Wrong!'
  1686.     
  1687.     print repr(s)
  1688.     print repr(qs)
  1689.     print repr(uqs)
  1690.     print round(t1 - t0, 3), 'sec'
  1691.  
  1692.  
  1693. def reporthook(blocknum, blocksize, totalsize):
  1694.     print 'Block number: %d, Block size: %d, Total size: %d' % (blocknum, blocksize, totalsize)
  1695.  
  1696.  
  1697. def test(args = []):
  1698.     if not args:
  1699.         args = [
  1700.             '/etc/passwd',
  1701.             'file:/etc/passwd',
  1702.             'file://localhost/etc/passwd',
  1703.             'ftp://ftp.gnu.org/pub/README',
  1704.             'http://www.python.org/index.html']
  1705.         if hasattr(URLopener, 'open_https'):
  1706.             args.append('https://synergy.as.cmu.edu/~geek/')
  1707.         
  1708.     
  1709.     
  1710.     try:
  1711.         for url in args:
  1712.             print '----------', url, '----------'
  1713.             (fn, h) = urlretrieve(url, None, reporthook)
  1714.             print fn
  1715.             if h:
  1716.                 print '======'
  1717.                 for k in h.keys():
  1718.                     print k + ':', h[k]
  1719.                 
  1720.                 print '======'
  1721.             
  1722.             fp = open(fn, 'rb')
  1723.             data = fp.read()
  1724.             del fp
  1725.             if '\r' in data:
  1726.                 table = string.maketrans('', '')
  1727.                 data = data.translate(table, '\r')
  1728.             
  1729.             print data
  1730.             (fn, h) = (None, None)
  1731.         
  1732.         print '-' * 40
  1733.     finally:
  1734.         urlcleanup()
  1735.  
  1736.  
  1737.  
  1738. def main():
  1739.     import getopt as getopt
  1740.     import sys
  1741.     
  1742.     try:
  1743.         (opts, args) = getopt.getopt(sys.argv[1:], 'th')
  1744.     except getopt.error:
  1745.         msg = None
  1746.         print msg
  1747.         print 'Use -h for help'
  1748.         return None
  1749.  
  1750.     t = 0
  1751.     for o, a in opts:
  1752.         if o == '-t':
  1753.             t = t + 1
  1754.         
  1755.         if o == '-h':
  1756.             print 'Usage: python urllib.py [-t] [url ...]'
  1757.             print '-t runs self-test;', 'otherwise, contents of urls are printed'
  1758.             return None
  1759.             continue
  1760.     
  1761.     if t:
  1762.         if t > 1:
  1763.             test1()
  1764.         
  1765.         test(args)
  1766.     elif not args:
  1767.         print 'Use -h for help'
  1768.     
  1769.     for url in args:
  1770.         print urlopen(url).read(),
  1771.     
  1772.  
  1773. if __name__ == '__main__':
  1774.     main()
  1775.  
  1776.